from django.db import models
import uuid
import re
from pypinyin import lazy_pinyin, Style
# Create your models here.
"""
Django 数据库迁移命令: 
python manage.py makemigrations
python manage.py migrate
.venv\Scripts\activate
"""

class Users(models.Model):
    username = models.CharField(max_length=100, verbose_name="用户名", unique=True, error_messages={
        'unique': '用户名已经存在',
        'max_length': '用户名不能超过100个字符',
        'blank': '用户名不能为空',
        'null': '用户名不能为空'
    })
    password = models.CharField(max_length=100, verbose_name="密码", error_messages={
        'max_length': '密码不能超过100个字符',
        'blank': '密码不能为空',
        'null': '密码不能为空'
    })
    email = models.EmailField(max_length=100, verbose_name="邮箱", unique=True, null=True, blank=True, error_messages={
        'unique': '邮箱已经存在',
        'invalid': '邮箱格式不正确',
        'max_length': '邮箱不能超过100个字符'
    })
    avatar = models.FileField(upload_to="avatar/", verbose_name="头像", null=True, blank=True)
    
    # 用户权限
    is_superuser_choices = (
        (1, '老板'),
        (2, '店长'),
        (3, '员工')
    )
    is_superuser = models.IntegerField(verbose_name="用户权限", choices=is_superuser_choices, default=3, error_messages={
        'invalid': '用户权限格式不正确'
    }, null=True, blank=True)
    
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间")

    def save(self, *args, **kwargs):
        if not (2 <= len(self.username) <= 6):
            raise ValueError("用户名长度必须在2到6个字符之间")
        super().save(*args, **kwargs)


# 商品分类
class Goods_Category(models.Model):
    name = models.CharField(max_length=10, verbose_name="分类名称", error_messages={
        'max_length': '分类名称不能超过10个字符',
        'blank': '分类名称不能为空',
        'null': '分类名称不能为空'
    })
    status_choices = (
        (1, '正常'),
        (2, '禁用'),
        (3, '临时维护')
    )
    status = models.IntegerField(verbose_name="状态", choices=status_choices, default=1, error_messages={
        'invalid': '状态格式不正确'
    })
    # 备注
    remark = models.TextField(verbose_name="备注", null=True, blank=True)
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间")


# 次分类
class Goods_Category_Sub(models.Model):
    name = models.CharField(max_length=10, verbose_name="次分类名称", error_messages={
        'max_length': '次分类名称不能超过10个字符',
        'blank': '次分类名称不能为空',
        'null': '次分类名称不能为空'
    })
    status_choices = (
        (1, '正常'),
        (2, '禁用'),
        (3, '临时维护')
    )
    status = models.IntegerField(verbose_name="状态", choices=status_choices, default=1, error_messages={
        'invalid': '状态格式不正确'
    })
    # 备注
    remark = models.TextField(verbose_name="备注", null=True, blank=True)
    # 父分类
    parent = models.ForeignKey(Goods_Category, on_delete=models.CASCADE, verbose_name="父分类")
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间")

    def __str__(self):
        return self.name
    

# 商品管理
class Product(models.Model):
    # 商品ID,可以空,但是不能重复,如果为空,则自动生成
    product_id = models.CharField(max_length=100, verbose_name="商品ID", error_messages={
        'max_length': '商品ID不能超过100个字符',
        'blank': '商品ID不能为空',
        'null': '商品ID不能为空',
        'unique': '商品ID已经存在'
    }, unique=True, null=True, blank=True   )
    name = models.CharField(max_length=30, verbose_name="商品名称", error_messages={
        'max_length': '商品名称不能超过30个字符',
        'blank': '商品名称不能为空',
        'null': '商品名称不能为空'
    })
    # 商品主分类
    category = models.ForeignKey(Goods_Category, on_delete=models.CASCADE, verbose_name="商品主分类", null=True, blank=True)
    # 商品次分类
    category_sub = models.ForeignKey(Goods_Category_Sub, on_delete=models.CASCADE, verbose_name="商品次分类", null=True, blank=True)
    # 商品价格
    price = models.DecimalField(max_digits=10, decimal_places=2, verbose_name="商品价格")
    # 商品总库存
    stock = models.IntegerField(verbose_name="商品总库存", default=0)
    # 商品描述
    description = models.TextField(verbose_name="商品描述", null=True, blank=True)
    # 商品状态
    status_choices = (
        (1, '正常'),
        (2, '下架'),
    )
    status = models.IntegerField(verbose_name="商品状态", choices=status_choices, default=1, error_messages={
        'invalid': '商品状态格式不正确'
    })
    # 商品进货价
    purchase_price = models.DecimalField(max_digits=10, decimal_places=2, verbose_name="商品进货价", default=0)
    # 商品上架员
    shelf_staff = models.IntegerField(verbose_name="商品上架员")
    # 货架数量
    shelf_number = models.IntegerField(verbose_name="货架数量", default=0, null=True, blank=True)
    # 仓库数量
    warehouse_number = models.IntegerField(verbose_name="仓库数量", default=0, null=True, blank=True)
    # 商品创建时间
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    # 商品更新时间
    update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间")
    # 商品拼音
    pinyin = models.CharField(max_length=100, verbose_name="商品拼音", null=True, blank=True)
    def save(self, *args, **kwargs):
        # 判断商品上架员是否存在
        if not Users.objects.filter(id=self.shelf_staff).exists():
            raise ValueError("商品上架员不存在")
        
        # 判断分类选择是否合法
        if self.category and self.category_sub:
            raise ValueError("商品不能同时属于主分类和次分类")
        if not self.category and not self.category_sub:
            raise ValueError("商品必须属于一个分类（主分类或次分类）")
        if not self.product_id:
            self.product_id = str(uuid.uuid4())
        # 商品ID必须是英文、数字、下划线和-
        if not re.match(r'^[a-zA-Z0-9_-]+$', self.product_id):
            raise ValueError("商品ID必须是英文、数字、下划线和-")
        # 商品拼音
        self.pinyin = ''.join([p[0] for p in lazy_pinyin(self.name, style=Style.FIRST_LETTER)])
        super().save(*args, **kwargs)
    class Meta:
        ordering = ['-create_time']  # 默认按 create_time 倒序


# 商品图片
class Goods_Image(models.Model):
    product = models.ForeignKey(Product, on_delete=models.CASCADE, verbose_name="商品")
    image = models.FileField(upload_to="product_image/", verbose_name="商品图片")
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间")


# 订单管理模块
class PayMethod(models.Model):
    name = models.CharField(verbose_name='支付名称', max_length=20)
    description = models.TextField(verbose_name='支付描述', null=True, blank=True)
    

class Order(models.Model):
    order_id = models.CharField(max_length=30, verbose_name="订单ID", error_messages={
        'max_length': '订单ID不能超过30个字符',
        'blank': '订单ID不能为空',
        'null': '订单ID不能为空'
    },primary_key=True)
    # 订单状态
    status_choices = (
        (1, '待支付'),
        (2, '已支付'),
        (3, '已取消'),
        (4, '已退款')
    )
    status = models.IntegerField(verbose_name="订单状态", choices=status_choices, default=1, error_messages={
        'invalid': '订单状态格式不正确'
    })
    # 购买的商品
    buy_goodsProduct = models.ForeignKey(Product, on_delete=models.CASCADE, verbose_name='购买的商品')
    # 购买的商品数量
    buy_goodsProduct_number = models.IntegerField(verbose_name='购买的商品数量', default=0)
    # 支付方式
    pay_method = models.ForeignKey(PayMethod, on_delete=models.CASCADE, verbose_name='支付方式')
    # 订单总价
    total_price = models.DecimalField(max_digits=10, decimal_places=2, verbose_name="订单总价")
    # 订单创建者
    create_user = models.ForeignKey(Users, on_delete=models.CASCADE, verbose_name="订单创建者")
    # 订单备注
    remark = models.TextField(verbose_name="订单备注", null=True, blank=True)
    # 订单创建时间
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    # 订单更新时间
    update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间")
    def save(self, *args, **kwargs):
        # 判断订单创建者是否存在
        if not Users.objects.filter(id=self.create_user_id).exists():
            raise ValueError("订单创建者不存在")
        # 判断支付方式是否存在
        if not PayMethod.objects.filter(id=self.pay_method_id).exists():
            raise ValueError("支付方式不存在")
        # 判断商品ID是否存在
        if not Product.objects.filter(id=self.buy_goodsProduct_id).exists():
            raise ValueError("商品ID不存在")
        
        super().save(*args, **kwargs)

    


# 打卡
class ClockIn(models.Model):
    user = models.ForeignKey(Users, on_delete=models.CASCADE, verbose_name="打卡用户")
    # 打卡类型
    clock_type_choices = (
        (1, '上班'),
        (2, '下班')
    )
    clock_type = models.IntegerField(verbose_name="打卡类型", choices=clock_type_choices, default=1, error_messages={
        'invalid': '打卡类型格式不正确',
        'blank': '打卡类型不能为空',
        'null': '打卡类型不能为空'
    })
    # 打卡地点
    clock_location = models.CharField(max_length=100, verbose_name="打卡地点", null=True, blank=True)
    # 打卡时间
    clock_time = models.DateTimeField(auto_now=True, verbose_name="打卡时间")
    # 打卡备注
    remark = models.TextField(verbose_name="打卡备注", null=True, blank=True)

# 打卡照片
class ClockInPhoto(models.Model):
    clock_in = models.ForeignKey(ClockIn, on_delete=models.CASCADE, verbose_name="打卡")
    photo = models.FileField(upload_to="clock_in_photo/", verbose_name="打卡照片")
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间")


# 盘点
class Inventory(models.Model):
    inventory_id = models.CharField(max_length=100, verbose_name="盘点ID", error_messages={
        'max_length': '盘点ID不能超过100个字符',
        'blank': '盘点ID不能为空',
        'null': '盘点ID不能为空'
    },primary_key=True)
    # 盘点类型
    inventory_type_choices = (
        (1, '货架'),
        (2, '仓库')
    )
    inventory_type = models.IntegerField(verbose_name="盘点类型", choices=inventory_type_choices, default=1, error_messages={
        'invalid': '盘点类型格式不正确'
    })
    # 盘点用户
    inventory_user = models.ForeignKey(Users, on_delete=models.CASCADE, verbose_name="盘点用户", error_messages={
        'invalid': '盘点用户不存在',
    })
    # 盘点备注
    remark = models.TextField(verbose_name="盘点备注", null=True, blank=True)
    # 盘点创建时间
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间")
    def save(self, *args, **kwargs):
        # 判断盘点用户是否存在
        if not Users.objects.filter(id=self.inventory_user_id).exists():
            raise ValueError("盘点用户不存在")
        # 判断盘点类型是否合法
        if self.inventory_type not in [1, 2]:
            raise ValueError("盘点类型不合法")
        if not self.inventory_id:
            self.inventory_id = str(uuid.uuid4())
        super().save(*args, **kwargs)

# 盘点详情
class InventoryDetail(models.Model):
    inventory = models.ForeignKey(Inventory, on_delete=models.CASCADE, verbose_name="盘点")
    # 盘点商品
    product = models.ForeignKey(Product, on_delete=models.CASCADE, verbose_name="盘点商品")
    # 盘点预计数量
    inventory_number = models.IntegerField(verbose_name="盘点数量", default=0)
    # 盘点实际数量
    inventory_actual_number = models.IntegerField(verbose_name="盘点实际数量", default=0)
    # 盘点差异数量
    inventory_difference_number = models.IntegerField(verbose_name="盘点差异数量", default=0)
    # 盘点差异原因
    inventory_difference_reason = models.TextField(verbose_name="盘点差异原因", null=True, blank=True)
    # 备注
    remark = models.TextField(verbose_name="备注", null=True, blank=True)
    # 盘点创建时间
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    
    

# 反馈
class Feedback(models.Model):
    feedback_id = models.CharField(max_length=100, verbose_name="反馈ID", error_messages={
        'max_length': '反馈ID不能超过100个字符',
        'blank': '反馈ID不能为空',
        'null': '反馈ID不能为空'
    },primary_key=True)
    # 反馈内容
    feedback_content = models.TextField(verbose_name="反馈内容", null=True, blank=True)
    # 反馈用户
    feedback_user = models.ForeignKey(Users, on_delete=models.CASCADE, verbose_name="反馈用户")
    # 反馈状态
    feedback_status_choices = (
        (1, '待处理'),
        (2, '已处理')
    )
    feedback_status = models.IntegerField(verbose_name="反馈状态", choices=feedback_status_choices, default=1, error_messages={
        'invalid': '反馈状态格式不正确'
    })
    # 反馈回复
    feedback_reply = models.TextField(verbose_name="反馈回复", null=True, blank=True)
    # 反馈回复时间
    feedback_reply_time = models.DateTimeField(verbose_name="反馈回复时间", null=True, blank=True)
    # 反馈回复用户
    feedback_reply_user = models.ForeignKey(Users, on_delete=models.CASCADE, verbose_name="反馈回复用户", null=True, blank=True, related_name="feedback_reply_user")
    # 反馈类型
    feedback_type_choices = (
        (1, '商品问题'),
        (2, '订单问题'),
        (3, '软件问题'),
        (100, '其他问题')
    )
    feedback_type = models.IntegerField(verbose_name="反馈类型", choices=feedback_type_choices, default=1, error_messages={
        'invalid': '反馈类型格式不正确'
    })
    # 反馈创建时间
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    # 反馈更新时间
    update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间")
    def save(self, *args, **kwargs):
        # 判断反馈用户是否存在
        if not Users.objects.filter(id=self.feedback_user_id).exists():
            raise ValueError("反馈用户不存在")
        if not self.feedback_id:
            self.feedback_id = str(uuid.uuid4())
        super().save(*args, **kwargs)


# 反馈图片
class FeedbackImage(models.Model):
    feedback = models.ForeignKey(Feedback, on_delete=models.CASCADE, verbose_name="反馈")
    image = models.FileField(upload_to="feedback_image/", verbose_name="反馈图片")
    # 图片类型
    image_type_choices = (
        (1, '反馈'),
        (2, '回复')
    )
    image_type = models.IntegerField(verbose_name="图片类型", choices=image_type_choices, default=1, error_messages={
        'invalid': '图片类型格式不正确'
    })
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间")


# 版本管理
class Version(models.Model):
    version_id = models.CharField(max_length=100, verbose_name="版本ID", error_messages={
        'max_length': '版本ID不能超过100个字符',
        'blank': '版本ID不能为空',
        'null': '版本ID不能为空'
    },primary_key=True)
    # 版本号
    version_number = models.CharField(max_length=100, verbose_name="版本号", error_messages={
        'max_length': '版本号不能超过100个字符',
        'blank': '版本号不能为空',
        'null': '版本号不能为空',
        'unique': '版本号已经存在'
    }, unique=True)
    # 版本描述
    version_description = models.TextField(verbose_name="版本描述", null=True, blank=True)
    # 版本状态
    version_status_choices = (
        (1, '正常'),
        (2, '维护')
    )
    version_status = models.IntegerField(verbose_name="版本状态", choices=version_status_choices, default=1, error_messages={
        'invalid': '版本状态格式不正确'
    })
    # 版本发布人
    version_publisher = models.ForeignKey(Users, on_delete=models.CASCADE, verbose_name="版本发布人", null=True, blank=True)
    # 版本下载地址
    version_download_url = models.CharField(max_length=200, verbose_name="版本下载地址", null=True, blank=True)
    # 版本创建时间
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    # 版本更新时间
    update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间")
    def save(self, *args, **kwargs):
        if not self.version_id:
            self.version_id = str(uuid.uuid4())
        super().save(*args, **kwargs)
# 版本类型
class Version_Type(models.Model):
    version = models.ForeignKey(Version, on_delete=models.CASCADE, verbose_name="版本")
    # 版本更新说明类型
    version_update_type_choices = (
        (1, '新增'),
        (2, '优化'),
        (3, '修复'),
        (4, '删除'),
        (100, '其他')
    )
    version_update_type = models.IntegerField(verbose_name="版本更新说明类型", choices=version_update_type_choices, default=1, error_messages={
        'invalid': '版本更新说明类型格式不正确'
    })
    # 版本更新说明
    version_update_description = models.TextField(verbose_name="版本更新说明", null=True, blank=True)
    # 版本创建时间
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    # 版本更新时间
    update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间")
# 版本图片
class VersionImage(models.Model):
    version = models.ForeignKey(Version, on_delete=models.CASCADE, verbose_name="版本")
    image = models.FileField(upload_to="version_image/", verbose_name="版本图片")
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间")


# 公告
class Notice(models.Model):
    notice_id = models.CharField(max_length=100, verbose_name="公告ID", error_messages={
        'max_length': '公告ID不能超过100个字符',
        'blank': '公告ID不能为空',
        'null': '公告ID不能为空'
    },primary_key=True)
    # 公告标题
    notice_title = models.CharField(max_length=100, verbose_name="公告标题", error_messages={
        'max_length': '公告标题不能超过100个字符',
        'blank': '公告标题不能为空',
        'null': '公告标题不能为空'
    })
    # 公告内容
    notice_content = models.TextField(verbose_name="公告内容", null=True, blank=True)
    # 发布人
    notice_publisher = models.ForeignKey(Users, on_delete=models.CASCADE, verbose_name="发布人", null=True, blank=True)
    # 公告创建时间
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    # 公告更新时间
    update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间")
    def save(self, *args, **kwargs):
        if not self.notice_id:
            self.notice_id = str(uuid.uuid4())
        super().save(*args, **kwargs)
# 公告图片
class NoticeImage(models.Model):
    notice = models.ForeignKey(Notice, on_delete=models.CASCADE, verbose_name="公告")
    image = models.FileField(upload_to="notice_image/", verbose_name="公告图片")
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间")

# 报废系统
class Scrap(models.Model):
    scrap_id = models.CharField(max_length=100, verbose_name="报废ID", error_messages={
        'max_length': '报废ID不能超过100个字符',
        'blank': '报废ID不能为空',
        'null': '报废ID不能为空'
    },primary_key=True)
    # 报废商品
    scrap_product = models.OneToOneField(Product, to_field='product_id', on_delete=models.CASCADE, verbose_name="报废商品",error_messages={
        'invalid': '报废商品不存在',
        'blank': '报废商品不能为空',
        'null': '报废商品不能为空',
        'unique': '报废商品已经存在,可以更新报废'
    }, unique=True)
    # 在货架报废还是在仓库报废
    scrap_location_choices = (
        (1, '货架'),
        (2, '仓库')
    )
    scrap_location = models.IntegerField(verbose_name="报废位置", choices=scrap_location_choices, default=1, error_messages={
        'invalid': '报废位置格式不正确'
    })
    # 报废数量
    scrap_number = models.IntegerField(verbose_name="报废数量", default=0)
    # 报废原因
    scrap_reason = models.TextField(verbose_name="报废原因", null=True, blank=True)
    # 报废用户
    scrap_user = models.ForeignKey(Users,error_messages={
        'invalid': '报废用户不存在',
        'blank': '报废用户不能为空',
        'null': '报废用户不能为空'
    }, on_delete=models.CASCADE, verbose_name="报废用户")
    # 报废创建时间
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间", error_messages={
        'null': '创建时间不能为空',
        'blank': '创建时间不能为空'
    })
    # 报废更新时间
    update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间", error_messages={
        'null': '更新时间不能为空',
        'blank': '更新时间不能为空'
    })
    def save(self, *args, **kwargs):
        if not self.scrap_id:
            self.scrap_id = str(uuid.uuid4())
        # 判断报废商品是否存在
        if not Product.objects.filter(product_id=self.scrap_product_id).exists():
            raise ValueError("报废商品不存在")
        # 判断报废用户是否存在
        if not Users.objects.filter(id=self.scrap_user_id).exists():
            raise ValueError("报废用户不存在")
        # 判断报废数量是否大于0
        if self.scrap_number <= 0:
            raise ValueError("报废数量不能小于等于0")
        # 判断报废数量是否大于商品库存
        if self.scrap_number > self.scrap_product.stock:
            raise ValueError("报废数量不能大于商品库存")
        # 报废商品后需要在商品表中减少库存
        self.scrap_product.stock -= self.scrap_number
        # 如果是在货架报废，则减少货架数量
        if self.scrap_location == 1:
            self.scrap_product.shelf_number -= self.scrap_number
            # 如果货架数量小于0，则抛出错误
            if self.scrap_product.shelf_number < 0:
                raise ValueError("货架数量不能小于0")
        # 如果是在仓库报废，则减少仓库数量
        else:
            self.scrap_product.warehouse_number -= self.scrap_number
            # 如果仓库数量小于0，则抛出错误
            if self.scrap_product.warehouse_number < 0:
                raise ValueError("仓库数量不能小于0")
        # 保存商品
        self.scrap_product.save()
        super().save(*args, **kwargs)

# 报废图片
class ScrapImage(models.Model):
    scrap = models.ForeignKey(Scrap, on_delete=models.CASCADE, verbose_name="报废")
    image = models.FileField(upload_to="scrap_image/", verbose_name="报废图片")
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间")



# 失物招领处系统
class LostAndFound(models.Model):
    lost_and_found_id = models.CharField(max_length=100, verbose_name="失物招领ID", error_messages={
        'max_length': '失物招领ID不能超过100个字符',
        'blank': '失物招领ID不能为空',
        'null': '失物招领ID不能为空'
    }, primary_key=True)

    # 失物招领物品名称
    lost_and_found_name = models.CharField(max_length=100, verbose_name="失物招领物品名称", error_messages={
        'max_length': '失物招领物品名称不能超过100个字符',
        'blank': '失物招领物品名称不能为空',
        'null': '失物招领物品名称不能为空'
    })
    # 失物招领物品描述
    lost_and_found_description = models.TextField(verbose_name="失物招领物品描述", null=True, blank=True)
    # 失物招领物品状态
    lost_and_found_status_choices = (
        (1, '待认领'),
        (2, '已认领'),
        (3, '已失效')
    )
    lost_and_found_status = models.IntegerField(verbose_name="失物招领物品状态", choices=lost_and_found_status_choices, default=1, error_messages={
        'invalid': '失物招领物品状态格式不正确'
    })
    # 认领者姓名
    lost_and_found_claimer_name = models.CharField(max_length=100, verbose_name="认领者姓名", null=True, blank=True)
    # 认领者联系方式
    lost_and_found_claimer_contact = models.CharField(max_length=100, verbose_name="认领者联系方式", null=True, blank=True)
    # 失物招领物品创建者
    lost_and_found_creator = models.ForeignKey(Users, on_delete=models.CASCADE, verbose_name="失物招领物品创建者", null=True, blank=True)
    # 失物招领物品位置
    lost_and_found_location = models.CharField(max_length=100, verbose_name="失物招领物品位置", null=True, blank=True)
    # 失物招领物品创建时间
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    # 失物招领物品更新时间
    update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间")

# 失物招领物品图片  
class LostAndFoundImage(models.Model):
    lost_and_found = models.ForeignKey(LostAndFound, on_delete=models.CASCADE, verbose_name="失物招领")
    # 失物招领物品图片类型
    lost_and_found_image_type_choices = (
        (1, '失物招领物品图片'),
        (2, '认领物品人照片')
    )
    lost_and_found_image_type = models.IntegerField(verbose_name="失物招领物品图片类型", choices=lost_and_found_image_type_choices, default=1, error_messages={
        'invalid': '失物招领物品图片类型格式不正确'
    })
    # 失物招领物品图片
    image = models.FileField(upload_to="lost_and_found_image/", verbose_name="失物招领物品图片")
    # 失物招领物品图片创建时间
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    # 失物招领物品图片更新时间
    update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间")


# 商品兄弟
"""
一个商品下可能会有兄弟分类，比如一个梳子，它可能有酷洛米梳子、美乐蒂梳子
但是它们是同一个商品，只是不同的分类
"""
class ProductBrother(models.Model):
    product = models.ForeignKey(Product, on_delete=models.CASCADE, verbose_name="商品", related_name='brothers_as_product', to_field='product_id',
                                error_messages={
                                    'invalid': '商品ID格式不正确',
                                    'blank': '商品ID不能为空',  
                                    'null': '商品ID不能为空',
                                    'required': '商品ID不能为空'
                                })
    brother_product = models.ForeignKey(Product, on_delete=models.CASCADE, verbose_name="兄弟商品", related_name='brothers_as_brother', to_field='product_id',
                                        error_messages={
                                            'invalid': '兄弟商品ID格式不正确',
                                            'blank': '兄弟商品ID不能为空',
                                            'null': '兄弟商品ID不能为空',
                                            'required': '兄弟商品ID不能为空'
                                        })
    create_time = models.DateTimeField(auto_now_add=True, verbose_name="创建时间")
    update_time = models.DateTimeField(auto_now=True, verbose_name="更新时间")


